{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=5\n",
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True\n",
    "#equation_component_combination = [1.0,2.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = loadmat('data.mat')['uxy_list'][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Noise 2%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = loadmat('data.mat')['uxy_list'][-1] + np.random.normal(loc=0.0, scale=0.02, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation_data = []\n",
    "\n",
    "theta_list = np.linspace(0,np.pi*2,800)\n",
    "for theta in theta_list:\n",
    "    x = x_theta(theta)\n",
    "    y = y_theta(theta)\n",
    "    comb = [1,0,0]\n",
    "    v = U(x,y)\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.14732 | domain_loss:  557.84418 | bdc_loss:    0.57462\n",
      "epoch:  200.00000 | total_loss:    0.89273 | domain_loss:   38.97194 | bdc_loss:    0.50810\n",
      "epoch:  400.00000 | total_loss:    0.53572 | domain_loss:    8.76450 | bdc_loss:    0.45260\n",
      "epoch:  600.00000 | total_loss:    0.43235 | domain_loss:    3.48973 | bdc_loss:    0.40147\n",
      "epoch:  800.00000 | total_loss:    0.36787 | domain_loss:    1.89691 | bdc_loss:    0.35243\n",
      "epoch: 1000.00000 | total_loss:    0.31543 | domain_loss:    1.20627 | bdc_loss:    0.30643\n",
      "epoch: 1200.00000 | total_loss:    0.27239 | domain_loss:    0.81149 | bdc_loss:    0.26695\n",
      "epoch: 1400.00000 | total_loss:    0.24101 | domain_loss:    0.55143 | bdc_loss:    0.23788\n",
      "epoch: 1600.00000 | total_loss:    0.22194 | domain_loss:    0.38158 | bdc_loss:    0.22033\n",
      "epoch: 1800.00000 | total_loss:    0.21224 | domain_loss:    0.27826 | bdc_loss:    0.21157\n",
      "epoch: 2000.00000 | total_loss:    0.20752 | domain_loss:    0.21893 | bdc_loss:    0.20741\n",
      "epoch: 2200.00000 | total_loss:    0.20466 | domain_loss:    0.18759 | bdc_loss:    0.20483\n",
      "epoch: 2400.00000 | total_loss:    0.20227 | domain_loss:    0.17517 | bdc_loss:    0.20254\n",
      "epoch: 2600.00000 | total_loss:    0.19988 | domain_loss:    0.17659 | bdc_loss:    0.20011\n",
      "epoch: 2800.00000 | total_loss:    0.19733 | domain_loss:    0.18904 | bdc_loss:    0.19741\n",
      "epoch: 3000.00000 | total_loss:    0.19452 | domain_loss:    0.21122 | bdc_loss:    0.19435\n",
      "epoch: 3200.00000 | total_loss:    0.19139 | domain_loss:    0.24301 | bdc_loss:    0.19087\n",
      "epoch: 3400.00000 | total_loss:    0.18783 | domain_loss:    0.28520 | bdc_loss:    0.18685\n",
      "epoch: 3600.00000 | total_loss:    0.18375 | domain_loss:    0.33940 | bdc_loss:    0.18218\n",
      "epoch: 3800.00000 | total_loss:    0.17903 | domain_loss:    0.40784 | bdc_loss:    0.17671\n",
      "epoch: 4000.00000 | total_loss:    0.17351 | domain_loss:    0.49319 | bdc_loss:    0.17028\n",
      "epoch: 4200.00000 | total_loss:    0.16705 | domain_loss:    0.59807 | bdc_loss:    0.16269\n",
      "epoch: 4400.00000 | total_loss:    0.15949 | domain_loss:    0.72407 | bdc_loss:    0.15378\n",
      "epoch: 4600.00000 | total_loss:    0.15071 | domain_loss:    0.87017 | bdc_loss:    0.14344\n",
      "epoch: 4800.00000 | total_loss:    0.14068 | domain_loss:    1.03064 | bdc_loss:    0.13169\n",
      "epoch: 5000.00000 | total_loss:    0.12951 | domain_loss:    1.19345 | bdc_loss:    0.11876\n",
      "epoch: 5200.00000 | total_loss:    0.11749 | domain_loss:    1.34073 | bdc_loss:    0.10513\n",
      "epoch: 5400.00000 | total_loss:    0.10515 | domain_loss:    1.45294 | bdc_loss:    0.09153\n",
      "epoch: 5600.00000 | total_loss:    0.09322 | domain_loss:    1.51626 | bdc_loss:    0.07884\n",
      "epoch: 5800.00000 | total_loss:    0.08250 | domain_loss:    1.52969 | bdc_loss:    0.06788\n",
      "epoch: 6000.00000 | total_loss:    0.07363 | domain_loss:    1.50605 | bdc_loss:    0.05916\n",
      "epoch: 6200.00000 | total_loss:    0.06685 | domain_loss:    1.46466 | bdc_loss:    0.05273\n",
      "epoch: 6400.00000 | total_loss:    0.06193 | domain_loss:    1.42152 | bdc_loss:    0.04820\n",
      "epoch: 6600.00000 | total_loss:    0.05842 | domain_loss:    1.38412 | bdc_loss:    0.04503\n",
      "epoch: 6800.00000 | total_loss:    0.05579 | domain_loss:    1.35277 | bdc_loss:    0.04269\n",
      "epoch: 7000.00000 | total_loss:    0.05363 | domain_loss:    1.32405 | bdc_loss:    0.04080\n",
      "epoch: 7200.00000 | total_loss:    0.05162 | domain_loss:    1.29383 | bdc_loss:    0.03907\n",
      "epoch: 7400.00000 | total_loss:    0.04953 | domain_loss:    1.25878 | bdc_loss:    0.03732\n",
      "epoch: 7600.00000 | total_loss:    0.04722 | domain_loss:    1.21742 | bdc_loss:    0.03540\n",
      "epoch: 7800.00000 | total_loss:    0.04459 | domain_loss:    1.15736 | bdc_loss:    0.03335\n",
      "epoch: 8000.00000 | total_loss:    0.04119 | domain_loss:    1.03697 | bdc_loss:    0.03113\n",
      "epoch: 8200.00000 | total_loss:    0.03688 | domain_loss:    0.86227 | bdc_loss:    0.02855\n",
      "epoch: 8400.00000 | total_loss:    0.03218 | domain_loss:    0.67715 | bdc_loss:    0.02566\n",
      "epoch: 8600.00000 | total_loss:    0.02773 | domain_loss:    0.52597 | bdc_loss:    0.02270\n",
      "epoch: 8800.00000 | total_loss:    0.02386 | domain_loss:    0.41986 | bdc_loss:    0.01986\n",
      "epoch: 9000.00000 | total_loss:    0.02054 | domain_loss:    0.34071 | bdc_loss:    0.01731\n",
      "epoch: 9200.00000 | total_loss:    0.01772 | domain_loss:    0.27967 | bdc_loss:    0.01508\n",
      "epoch: 9400.00000 | total_loss:    0.01533 | domain_loss:    0.23187 | bdc_loss:    0.01314\n",
      "epoch: 9600.00000 | total_loss:    0.01330 | domain_loss:    0.19380 | bdc_loss:    0.01147\n",
      "epoch: 9800.00000 | total_loss:    0.01156 | domain_loss:    0.16317 | bdc_loss:    0.01002\n",
      "epoch: 10000.00000 | total_loss:    0.01005 | domain_loss:    0.13782 | bdc_loss:    0.00876\n",
      "epoch: 10200.00000 | total_loss:    0.00871 | domain_loss:    0.11619 | bdc_loss:    0.00763\n",
      "epoch: 10400.00000 | total_loss:    0.00752 | domain_loss:    0.09734 | bdc_loss:    0.00661\n",
      "epoch: 10600.00000 | total_loss:    0.00645 | domain_loss:    0.08117 | bdc_loss:    0.00569\n",
      "epoch: 10800.00000 | total_loss:    0.00547 | domain_loss:    0.06567 | bdc_loss:    0.00487\n",
      "epoch: 11000.00000 | total_loss:    0.00464 | domain_loss:    0.05354 | bdc_loss:    0.00414\n",
      "epoch: 11200.00000 | total_loss:    0.00393 | domain_loss:    0.04364 | bdc_loss:    0.00353\n",
      "epoch: 11400.00000 | total_loss:    0.00334 | domain_loss:    0.03655 | bdc_loss:    0.00301\n",
      "epoch: 11600.00000 | total_loss:    0.00278 | domain_loss:    0.02883 | bdc_loss:    0.00252\n",
      "epoch: 11800.00000 | total_loss:    0.00225 | domain_loss:    0.02120 | bdc_loss:    0.00206\n",
      "epoch: 12000.00000 | total_loss:    0.00180 | domain_loss:    0.01572 | bdc_loss:    0.00166\n",
      "epoch: 12200.00000 | total_loss:    0.00146 | domain_loss:    0.01210 | bdc_loss:    0.00135\n",
      "epoch: 12400.00000 | total_loss:    0.00118 | domain_loss:    0.00887 | bdc_loss:    0.00110\n",
      "epoch: 12600.00000 | total_loss:    0.00096 | domain_loss:    0.00658 | bdc_loss:    0.00090\n",
      "epoch: 12800.00000 | total_loss:    0.00078 | domain_loss:    0.00475 | bdc_loss:    0.00074\n",
      "epoch: 13000.00000 | total_loss:    0.00064 | domain_loss:    0.00336 | bdc_loss:    0.00061\n",
      "epoch: 13200.00000 | total_loss:    0.00054 | domain_loss:    0.00232 | bdc_loss:    0.00052\n",
      "epoch: 13400.00000 | total_loss:    0.00046 | domain_loss:    0.00151 | bdc_loss:    0.00045\n",
      "epoch: 13600.00000 | total_loss:    0.00040 | domain_loss:    0.00101 | bdc_loss:    0.00039\n",
      "epoch: 13800.00000 | total_loss:    0.00037 | domain_loss:    0.00127 | bdc_loss:    0.00036\n",
      "epoch: 14000.00000 | total_loss:    0.00033 | domain_loss:    0.00035 | bdc_loss:    0.00033\n",
      "epoch: 14200.00000 | total_loss:    0.00032 | domain_loss:    0.00047 | bdc_loss:    0.00032\n",
      "epoch: 14400.00000 | total_loss:    0.00031 | domain_loss:    0.00011 | bdc_loss:    0.00031\n",
      "epoch: 14600.00000 | total_loss:    0.00030 | domain_loss:    0.00006 | bdc_loss:    0.00030\n",
      "epoch: 14800.00000 | total_loss:    0.00031 | domain_loss:    0.00079 | bdc_loss:    0.00030\n",
      "epoch: 15000.00000 | total_loss:    0.00030 | domain_loss:    0.00022 | bdc_loss:    0.00030\n",
      "epoch: 15200.00000 | total_loss:    0.00030 | domain_loss:    0.00003 | bdc_loss:    0.00030\n",
      "epoch: 15400.00000 | total_loss:    0.00030 | domain_loss:    0.00022 | bdc_loss:    0.00030\n",
      "epoch: 15600.00000 | total_loss:    0.00030 | domain_loss:    0.00056 | bdc_loss:    0.00030\n",
      "epoch: 15800.00000 | total_loss:    0.00030 | domain_loss:    0.00087 | bdc_loss:    0.00030\n",
      "epoch: 16000.00000 | total_loss:    0.00030 | domain_loss:    0.00082 | bdc_loss:    0.00030\n",
      "epoch: 16200.00000 | total_loss:    0.00030 | domain_loss:    0.00002 | bdc_loss:    0.00030\n",
      "epoch: 16400.00000 | total_loss:    0.00030 | domain_loss:    0.00010 | bdc_loss:    0.00030\n",
      "epoch: 16600.00000 | total_loss:    0.00030 | domain_loss:    0.00046 | bdc_loss:    0.00030\n",
      "epoch: 16800.00000 | total_loss:    0.00030 | domain_loss:    0.00005 | bdc_loss:    0.00030\n",
      "epoch: 17000.00000 | total_loss:    0.00030 | domain_loss:    0.00016 | bdc_loss:    0.00030\n",
      "epoch: 17200.00000 | total_loss:    0.00033 | domain_loss:    0.00334 | bdc_loss:    0.00030\n",
      "epoch: 17400.00000 | total_loss:    0.00030 | domain_loss:    0.00099 | bdc_loss:    0.00030\n",
      "epoch: 17600.00000 | total_loss:    0.00030 | domain_loss:    0.00002 | bdc_loss:    0.00030\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.00030 | domain_loss:    0.00009 | bdc_loss:    0.00030\n",
      "epoch: 18000.00000 | total_loss:    0.00030 | domain_loss:    0.00002 | bdc_loss:    0.00030\n",
      "epoch: 18200.00000 | total_loss:    0.00030 | domain_loss:    0.00008 | bdc_loss:    0.00030\n",
      "epoch: 18400.00000 | total_loss:    0.00030 | domain_loss:    0.00003 | bdc_loss:    0.00030\n",
      "epoch: 18600.00000 | total_loss:    0.00030 | domain_loss:    0.00009 | bdc_loss:    0.00030\n",
      "epoch: 18800.00000 | total_loss:    0.00030 | domain_loss:    0.00002 | bdc_loss:    0.00030\n",
      "epoch: 19000.00000 | total_loss:    0.00030 | domain_loss:    0.00002 | bdc_loss:    0.00030\n",
      "epoch: 19200.00000 | total_loss:    0.00030 | domain_loss:    0.00007 | bdc_loss:    0.00030\n",
      "epoch: 19400.00000 | total_loss:    0.00030 | domain_loss:    0.00002 | bdc_loss:    0.00030\n",
      "epoch: 19600.00000 | total_loss:    0.00030 | domain_loss:    0.00063 | bdc_loss:    0.00030\n",
      "epoch: 19800.00000 | total_loss:    0.00032 | domain_loss:    0.00267 | bdc_loss:    0.00030\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0002), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'conv2d_7/kernel:0' shape=(1, 1, 2, 1) dtype=float32, numpy=\n",
       " array([[[[0.21147214],\n",
       "          [1.0597719 ]]]], dtype=float32)>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99776625"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.19955325*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth_data':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),truth_data\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0),\n",
    "                     'k1':pde_model_train.layers[-6].weights[0][0,0,0,0].numpy(),\n",
    "                     'k2':pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.21147214"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0597719"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.011402"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.22804260253906247"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()-5)/5*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
